/**
 * 🔐 通用登录验证工具
 * 提供严格的登录检查功能，确保用户必须登录才能访问敏感功能
 */

// 📊 登录状态检查结果
const LOGIN_CHECK_RESULT = {
  SUCCESS: 'success',
  WECHAT_SESSION_INVALID: 'wechat_session_invalid',
  LOCAL_LOGIN_INVALID: 'local_login_invalid',
  CLOUD_USER_INVALID: 'cloud_user_invalid',
  NETWORK_ERROR: 'network_error'
}

/**
 * 🔐 执行严格的登录状态检查
 * @returns {Promise<Object>} 检查结果
 */
async function performStrictLoginCheck() {
  console.log('🔐 开始执行严格登录检查...')
  
  try {
    // 第一步：检查微信session是否有效
    const wechatSessionValid = await checkWechatSession()
    
    if (!wechatSessionValid) {
      console.log('❌ 微信session无效，用户未登录')
      return {
        success: false,
        type: LOGIN_CHECK_RESULT.WECHAT_SESSION_INVALID,
        message: '微信登录已过期，请重新登录'
      }
    }
    
    // 第二步：检查本地登录状态
    const localLoginValid = checkLocalLoginStatus()
    
    if (!localLoginValid) {
      console.log('❌ 本地登录状态无效')
      return {
        success: false,
        type: LOGIN_CHECK_RESULT.LOCAL_LOGIN_INVALID,
        message: '本地登录状态无效，请重新登录'
      }
    }
    
    // 第三步：验证云端用户信息
    const cloudUserValid = await validateCloudUser()
    
    if (!cloudUserValid.isValid) {
      console.log('❌ 云端用户验证失败:', cloudUserValid.error)
      return {
        success: false,
        type: LOGIN_CHECK_RESULT.CLOUD_USER_INVALID,
        message: cloudUserValid.error
      }
    }
    
    // 所有检查通过
    console.log('✅ 所有登录检查通过')
    return {
      success: true,
      type: LOGIN_CHECK_RESULT.SUCCESS,
      message: '登录验证成功',
      userInfo: cloudUserValid.userInfo
    }
    
  } catch (error) {
    console.error('❌ 登录检查过程出错:', error)
    return {
      success: false,
      type: LOGIN_CHECK_RESULT.NETWORK_ERROR,
      message: '登录检查出错: ' + error.message
    }
  }
}

/**
 * 检查微信session是否有效
 * @returns {Promise<boolean>}
 */
function checkWechatSession() {
  return new Promise((resolve) => {
    wx.checkSession({
      success: () => {
        console.log('✅ 微信session有效')
        resolve(true)
      },
      fail: () => {
        console.log('❌ 微信session已过期')
        // 清除本地登录状态
        clearLocalLoginData()
        resolve(false)
      }
    })
  })
}

/**
 * 检查本地登录状态
 * @returns {boolean}
 */
function checkLocalLoginStatus() {
  const isLoggedIn = wx.getStorageSync('isLoggedIn')
  const userInfo = wx.getStorageSync('userInfo')
  
  console.log('📱 检查本地登录状态:', { isLoggedIn, hasUserInfo: !!userInfo })
  
  if (!isLoggedIn || !userInfo || !userInfo.openid) {
    console.log('❌ 本地登录状态检查失败')
    return false
  }
  
  console.log('✅ 本地登录状态有效')
  return true
}

/**
 * 验证云端用户信息
 * @returns {Promise<Object>}
 */
async function validateCloudUser() {
  try {
    console.log('☁️ 验证云端用户信息...')
    
    const result = await wx.cloud.callFunction({
      name: 'userManager',
      data: {
        action: 'getUserInfo'
      }
    })

    if (result.result.success) {
      const userInfo = result.result.userInfo
      console.log('✅ 云端用户信息验证成功:', userInfo.nickName || userInfo.openid)
      
      // 检查用户信息完整性
      if (!userInfo.openid) {
        return {
          isValid: false,
          error: '用户openid缺失，请重新登录'
        }
      }
      
      return {
        isValid: true,
        userInfo: userInfo
      }
    } else {
      return {
        isValid: false,
        error: result.result.error || '云端用户信息验证失败'
      }
    }
  } catch (error) {
    console.error('❌ 云端用户信息验证异常:', error)
    return {
      isValid: false,
      error: '网络异常或云函数错误，请检查网络连接'
    }
  }
}

/**
 * 清除本地登录数据
 */
function clearLocalLoginData() {
  console.log('🗑️ 清除本地登录数据')
  wx.removeStorageSync('userInfo')
  wx.removeStorageSync('isLoggedIn')
}

/**
 * 🔐 要求登录的装饰器函数
 * @param {Function} callback 登录成功后执行的回调函数
 * @param {Object} options 配置选项
 * @returns {Promise<boolean>} 是否登录成功
 */
async function requireLogin(callback, options = {}) {
  const { 
    showModal = true, 
    modalTitle = '需要登录',
    modalContent = '此功能需要登录后才能使用，是否立即前往登录？',
    skipCheck = false 
  } = options
  
  try {
    // 如果跳过检查，直接从本地状态判断
    if (skipCheck) {
      const isLoggedIn = wx.getStorageSync('isLoggedIn')
      if (!isLoggedIn) {
        if (showModal) {
          showLoginModal(modalTitle, modalContent)
        }
        return false
      }
      
      if (typeof callback === 'function') {
        return await callback()
      }
      return true
    }
    
    // 执行完整的登录检查
    const checkResult = await performStrictLoginCheck()
    
    if (!checkResult.success) {
      console.log(`❌ 登录检查失败: ${checkResult.message}`)
      
      if (showModal) {
        showLoginModal(modalTitle, checkResult.message)
      }
      
      return false
    }
    
    // 登录检查通过，执行回调
    if (typeof callback === 'function') {
      return await callback(checkResult.userInfo)
    }
    
    return true
    
  } catch (error) {
    console.error('❌ requireLogin 执行失败:', error)
    
    if (showModal) {
      wx.showToast({
        title: '登录验证失败',
        icon: 'none'
      })
    }
    
    return false
  }
}

/**
 * 显示登录提示弹窗
 * @param {string} title 弹窗标题
 * @param {string} content 弹窗内容
 */
function showLoginModal(title = '需要登录', content = '此功能需要登录后才能使用，是否立即前往登录？') {
  wx.showModal({
    title: title,
    content: content,
    confirmText: '去登录',
    cancelText: '取消',
    success: (res) => {
      if (res.confirm) {
        wx.switchTab({
          url: '/pages/profile/profile'
        })
      }
    }
  })
}

/**
 * 🔐 检查用户是否已登录（仅检查本地状态，不进行网络验证）
 * @returns {boolean}
 */
function isUserLoggedIn() {
  const isLoggedIn = wx.getStorageSync('isLoggedIn')
  const userInfo = wx.getStorageSync('userInfo')
  return !!(isLoggedIn && userInfo && userInfo.openid)
}

/**
 * 🔐 获取当前用户信息（仅从本地获取）
 * @returns {Object|null}
 */
function getCurrentUserInfo() {
  if (isUserLoggedIn()) {
    return wx.getStorageSync('userInfo')
  }
  return null
}

/**
 * 🔐 强制用户重新登录
 */
function forceRelogin(reason = '登录状态异常') {
  clearLocalLoginData()
  
  wx.showModal({
    title: '需要重新登录',
    content: `${reason}，请重新登录以继续使用。`,
    showCancel: false,
    confirmText: '去登录',
    success: () => {
      wx.switchTab({
        url: '/pages/profile/profile'
      })
    }
  })
}

/**
 * 🛡️ 页面级登录保护混入
 * 为页面提供统一的登录检查机制
 */
const loginProtectionMixin = {
  data: {
    isLoggedIn: false,
    loginChecked: false,
    currentUser: null
  },

  /**
   * 页面加载时自动执行登录检查
   */
  async checkLoginOnLoad() {
    console.log('🔐 页面加载，执行登录检查...')
    
    this.setData({
      isLoggedIn: false,
      loginChecked: false,
      currentUser: null
    })
    
    const checkResult = await performStrictLoginCheck()
    
    this.setData({
      isLoggedIn: checkResult.success,
      loginChecked: true,
      currentUser: checkResult.userInfo || null
    })
    
    return checkResult
  },

  /**
   * 页面显示时重新检查登录状态
   */
  async recheckLoginOnShow() {
    if (!this.data.loginChecked) {
      return await this.checkLoginOnLoad()
    }
    
    // 简单检查微信session
    const sessionValid = await checkWechatSession()
    
    if (!sessionValid) {
      this.setData({
        isLoggedIn: false,
        loginChecked: true,
        currentUser: null
      })
    }
    
    return { success: sessionValid }
  },

  /**
   * 页面级的requireLogin方法
   */
  requireLogin(callback, options = {}) {
    if (!this.data.isLoggedIn || !this.data.loginChecked) {
      showLoginModal()
      return false
    }
    
    if (typeof callback === 'function') {
      return callback(this.data.currentUser)
    }
    
    return true
  }
}

module.exports = {
  performStrictLoginCheck,
  checkWechatSession,
  checkLocalLoginStatus,
  validateCloudUser,
  clearLocalLoginData,
  requireLogin,
  showLoginModal,
  isUserLoggedIn,
  getCurrentUserInfo,
  forceRelogin,
  loginProtectionMixin,
  LOGIN_CHECK_RESULT
} 